The upstream has changed its way to handle the generic fields table.
The generic_fields_tbl_ now maps each object to an imemo:fields, and the
imemo:fields object will hold all the fields.  We now treat the
imemo:fields object as a child of its corresponding key in
generic_fields_tbl_, which is just like CRuby's default GC.  Like the
default GC, we handle generic_fields_tbl_ like other weak tables during
weak processing time.

On the Rust side, we replaced the moved_gen_fields_tables hash map with
a simple "backwarding table" that simply maps each moved object using
generic_fields_tbl_ to its old address.

This is a reguler merging commit that synchronizes the MMTK's CRuby fork
with the upstream.

The upstream introduced the imemo:fields type, and is now using it for
the `generic_fields_tbl_`, i.e. it now holds instance variables for
objects other than `T_OBJECT`, `T_CLASS` and `T_MODULE`.  When using
MMTk, we treat the key-value pair in the `generic_fields_tbl_` as a
strong edge, i.e. treating the imemo:fields of an object as if it were a
child.  We now update the `generic_fields_tbl_` like other weak tables.
This simplified the handling of generic fields table in the MMTk
binding.

With imemo:fields added, we now have 17 imemo types including MMTk's
imemo:mmtk_strbuf and imemo:mmtk_objbuf.  We increased the header bits
of the imemo type to 5 bits and changed the value of some imemo-specific
header offsets, such as `ISEQ_TRANSLATED`.

The upstream changed the API for acquiring/releasing the GVL.  We make
changes accordingly.

YJIT assumes there is only one thread doing GC.  It panics when two GC
worker threads try to mark two iseq objects simultaneously.  We made
several changes to support parallel GC for YJIT-compiled iseq objects:

1.  We replaced `Block::gc_obj_offsets` with `Block::gc_obj_addresses`
    which are now absolute pointers instead of offsets.  By doing so, we
    no longer need to borrow the `Rc<RefCell<VirtualMem>>` during GC.
2.  `rb_yjit_iseq_update_references` no longer uses `CodeBlock` to write
    code, and no longer calls `mark_all_executable` after updating each
    object.  Instead we make the whole code memory writable before
    updating any objects, and make it executable after the updating
    phase finishes.  This should both make it friendly to parallel GC
    and improve performance.

The upstream now acquires the GVL when adding a freed fiber to the fiber
pool.  Since MMTk worker threads cannot acquire the GVL, and MMTk only
calls `obj_free` in one GC worker thread, we skip the GVL when using
MMTk.

Previously we didn't process the newly added cc_refinement table, and
caused crashes.

We re-organized the order of weak table processing functions, and follow
the order as listed in `rb_gc_vm_weak_table_foreach` in `gc.c`, so that
we don't miss a table.  We also replaced functions that get tables with
functions that simply get table sizes.